- במפלס התחתון (בתחתית המדרגות) ובמפלס העליון (בראש המדרגות) יש מקום לכל הולכי הרגל

Transcription

1 אוניברסיטת בן-גוריון מדור בחינות מספר נבחן: רשמו תשובותיכם בגיליון התשובות בלבד תשובות מחוץ לגיליון לא יבדקו. בהצלחה! תאריך הבחינה: שם המורה: פרופ' מיכאל אלחדד ד"ר מני אדלר ד"ר אנדרי שרף שם הקורס: תכנות מערכות מספר הקורס: מיועד לתלמידי: מדעי המחשב, הנדסת תוכנה שנה: תשע"א סמסטר: א' מועד: א' משך הבחינה: שלש שעות חומר עזר: אסור 30) שאלה 1 נקודות) במקומות ציבוריים רבים (כמו לדוגמא, ברכבת התחתית המפורסמת של תל אביב) מותקנת מערכת של מדרגות נעות, לשם עליה וירידה בין מפלסים. בשאלה זו נעסוק בסימולציה של מנגנון זה. המערכת מורכבת מהאובייקטים הפסיביים הבאים:.(StairCase על כל מדרגה יש מקום להולך רגל אחד. StairCase) גרם מדרגות - במפלס התחתון (בתחתית המדרגות) ובמפלס העליון (בראש המדרגות) יש מקום לכל הולכי הרגל - שלו במרחב, כולל את הגובה הולך רגל המצב הפנימי של Pedestrian) ), קבוצה של הולכי רגל -.(Strategy ואסטרטגית התקדמות Strategy) הגובה של הולך הרגל, ניתן על ידי הגובה של המפלס התחתון ומספר המדרגות מהמפלס התחתון למקום בו הוא עומד. לדוגמא, אם גובה המפלס התחתון הוא 5, והולך הרגל נמצא 39 מדרגות מעל המפלס, נאמר כי גובהו הוא 44. אסטרטגיית ההתקדמות, קובעת את התנהגות הולך הרגל כאשר הוא נמצא בגרם מדרגות. המחזירה את הגובה החדש אליו next(),strategy עם מתודת ההתקדמות קיימים שלשה מימושים לממשק יגיע הולך הרגל: - הולך הרגל אינו עולה או יורד, אלא ממתין על המדרגה בה הוא עומד. Relaxed o - הולך הרגל מנסה להתקדם עצמאית מעלה HurryUp o - הולך הרגל מנסה להתקדם עצמאית מטה. HurryDown o בנוסף מוגדרים במערכת שני סוגים של אובייקטים אקטיביים: nt - Thread ('חוט') הרץ מעל המשימה המדרגות בקצב נתון. Movement - Thread ('חוט') הרץ מעל המשימה במורד גרם מדרגות בהתאם לאסטרטגית ההתקדמות שלו. StairCaseMovement Pedestrian edestrianmovement על גרם מדרגות: הנעה כלפי מעלה של גרם על הולך רגל: קידום הולך רגל במעלה או בסימולציה הנתונה, קיים גרם מדרגות אחד העולה מעלה, ושני הולכי רגל: הולך במפלס התחתון המנסה לעלות מעלה בנוסף להתקדמות המדרגות הנעות (אסטרטגיית - own הולך רגל במפלס העליון המנסה לרדת מטה נגד כיוון המדרגות הנעות (אסטרטגית - התבוננו בקטעי הקוד המממשים את המערכת וענו על השאלות שאחר כך:.(HurryUp.( HurryDown 1

2 2 interface Strategy { int next(int height); class Relaxed implements Strategy { public int next(int height) { return height; class HurryUp implements Strategy { public int next(int height) ) { return height+1; class HurryDown implements Strategy { public int next(int height) { return height-1; interface Pedestrian { int getheight(); void setheight(int int height); Strategy getstrategy(); void advance ance(staircase staircase); class Passenger implements Ped edestrian estrian { private int _height height; private final Strategy _strategy; Passenger (int height,, Strategy strategy) ) { _height = height; _strategy = strategy; public synchronized Strategy getstrategy() { return _strategy; _ public synchronized int getheight Height() { return _height _ height; ; public synchronized void setheight(int height) { _height = height; public void advance(staircase staircase) ) { //@TODO 2

3 3 interface StairCase { int fromheight Height(); int toheight Height(); Pedestria edestrian getpedestrian edestrian(int int i); i void setpedestrian edestrian(p (Pedestrian pedestrian,int i); int size(); int capacity(); class StairCaseImpl implements StairCase { private final Pedestrian edestrian[] _pedestrian edestrians; s; private final int _fromheight; private final int _toheight; StairCaseImpl(int int fromheight Height, int toheight Height) ) { _fromheight = fromheight; _to toheight = toheight; _pedestrian edestrians s = new PedestrianP edestrian[_toheight - _fromheight + 1] 1 ; public int fromheight () { return _fromheight _ fromheight; ; public int toheight () { return _toheight; public int capacity() { return _pedestrian edestrians. s.length length; public synchronized int size() { int size=0; for (Pedestrian p : _pedestrian edestrians) s) if (p!=null) size++; return size; public synchronized Pedestrian P getpedestrian edestrian(int int i) { return _pedestrian edestrians[i]; s[i]; public synchronized void setpedestrian edestrian(pedestrian p,, int i) i ) { _pedestrian edestrians[i [i] ] = p; class StairCaseMovementTask implements Runnable { 3

4 4 private final StairCase _staircase; private final long _speed; StairCaseMovementTask(StairCase staircase, long speed) { _staircase = staircase ; _speed = speed; public void run() { while (true) { try { for (int i=_staircase.capacity. capacity() ()-1; ; i>0; i--i --) ) { _staircase.setp setpedestrian edestrian(_staircase. _staircase.getp getpedestrian edestrian(i (i-1),i); Pedestrian p = _staircase.getp getpedestrian edestrian(i) i); if (p!=null) p.setheight(p..setheight(p.getheight()+1); getheight()+1); _staircase.setp setpedestrian edestrian(null,0); null,0); synchromized(_staircase staircase) ) { _staircase.notifyall(); Thread.sleep(_speed); catch (InterruptedException e) { class Pedestrian edestrianmovement MovementTask implements Runnable { private final Pedestrian _pedestrian edestrian; private final StairCase _staircase; private final long _speed; Pedestrian edestrianmovement MovementTask Task(Pedestrian pedestrian edestrian,, long speed,, StairCase staircase) ) { _pedestrian = pedestrian edestrian; ; _speed = speed; _staircase = staircase ; public void run() { while (true) { try { _pedestrian edestrian.advance(.advance(_staircase _staircase); Thread.sleep(_speed); catch (InterruptedException e) { return; class Simulation { public static void main(string[] args) { StairCase upstaircase = new StairCaseImpl(1, 39); Pedestrian pedestrian edestrian1 = new Passenger(1,new new HurryUp() ()); ); Pedestrian pedestrian edestrian2 = new Passenger(39 39,new HurryDown() ()); ); new Thread(new StairCaseMovementTask (upstaircase,1000 upstaircase,1000)).start(); 4

5 5 new Thread(new Pedestrian edestrianmovementtask (pedestrian edestrian1, , upstaircase)).start(); new Thread(new Pedestrian edestrianmovementtask (pedestrian edestrian2, , upstaircase)).start();,staircase וציינו (ונמקו) האם המחלקה א. הגדירו תכונה נשמרת (invariant) עבור הממשק (StairCase תחת כל חישוב מקבילי [10 נקודות] המממשת אותה בטוחה (במובן שמירה על האינווריאנטה של StairCaseImpl - Pedestrian בממשק advance() ב. הגדירו תנאי התחלה וסיום conditions) (pre/post עבור המתודה המקדמת את הולך הרגל בגרם המדרגות (הניתן כפרמטר) על פי האסטרטגיה שלו - וממשו את המתודה.Passenger במידה וקיים הולך רגל במדרגה הבאה, יש להמתין עד שהמקום יתפנה. [12 נקודות] במחלקה,StairCaseMovementTask ג. הראו כיצד ביטול הת'רד המבצע את.(deadlock) 8] נקודות] מביאה את הסימולציה למצב של ח בק class Simulation { public static void main(string[] args) { StairCase upstaircase = new StairCaseImpl(1, 39); Pedestrian pedestrian edestrian1 = new Passenger(1,new HurryUp()); ); Pedestrian ped edestrian estrian2 = new Passenger(39 39,new HurryDown()); new Thread(new StairCaseMovementTask (upstaircase,1000)).start(); new Thread(new Pedestrian edestrianmovementtask (pedestrian edestrian1, , upstaircase)).start(); new Thread(new Pedestrian edestrianmovementtask (pedestr edestrian ian2, , upstaircase)).start(); 30) שאלה 2 נקודות) משאלה.1 StairCaseImpl StairCase ו א. ממשו ב ++C את המחלקות ובביצוע השמה של ערך לאובייקט מסוג StairCaseImpl by של אובייקט מטיפוס value יש לתמוך בהעברה.(Java,StairCaseImpl שאינן קיימת ב במחלקה assignment operator ו copy constructor =) StairCase אין צורך לממש את הסנכרון. [18 נקודות] ב. ציירו את תמונת הזיכרון, כאשר מריצים את main ומגיעים למקום המסומן בתוך קוד המתודה [12 Q נקודות] void Q(const StairCase& staircase) { std::cout << "Mr. Memory, What t are the 39 steps?"; //@@ הזיכרון כאשר הרצת הקוד מגיעה לכאן תמונת לצייר את יש void main() { StairCaseImpl upstaircase(1, 39); StairCase* downstaircase = new StairCaseImpl Impl(1,39 (1,39); StairCaseImpl upstaircase2 = upstaircase; Q(upStairCase2); 5

6 6 30) שאלה 3 נקודות) בישיבת הנהלה של החברה המפעילה את המדרגות הנעות הוחלט, כי לשם בקרה על המערכת, הנעת גרם המדרגות - תתבצע בהפעלה מרחוק מתוך תהליך אחר המפעיל את כל StairCaseMovementTask כלומר ביצוע המשימה המדרגות הנעות של החברה, באתרים השונים. להלן קוד של התהליך המפעיל ממוקד הבקרה גרם מדרגות הנמצא באתר מרוחק. על מנת לקבל stub לגרם המדרגות המוגדר בזיכרון של התהליך המריץ את rmiregistry התהליך פונה ל Simulation בעמוד 4), ולאחר מכן מריץ על גרם מדרגות זה את המשימה הסימולציה בשאלה הראשונה (המחלקה.StairCaseMovementTask public class StairCaseControl { public static void main(string[] args) { try { StairCase upstaircase = (StairCase)Naming.lookup(" :4004/StairCase1"); new Thread(new StairCaseMovementTask (upstaircase,1000 upstaircase,1000)).start(); catch (Exception e) { e.printstacktrace(); א. ב. ג. ד. משאלה 1, כך שיתאימו למערכת החדשה. StairCaseImpl,StairCase ו,Simulation שנו את המחלקות [10 נקודות] הערה: התעלמו מיישום מחדש של מנגנון wait/notify במחלקות האחרות (כלומר, אין צורך לממש את notify בזיכרון של תהליך שני). התמקדו בשינוי האופי של בזיכרון של תהליך אחד ו wait האופן בו מבוצע.StairCase לאחר כמה פעולות תקשורת יתקדמו המדרגות הנעות מעלה בשלושה שלבים? (ניתן להניח כי תנאי ההתחלה תמיד מתקיימים). פרטו. [7 נקודות] StairCaseImpl.class האם הקובץ צריך להיות מוגדר במערכת הקבצים של המחשב בו רץ התהליך?StairCaseControl נמקו. [3 נקודות].Reactor,Stub מתבסס על תבנית ה עם ה StairCase של Skel נתון כי מימוש תקשורת ה ProtocolTask מסונכרנת. ocoltask כזכור, מתודת ה run() במחלקה סטודנט בקורס תכנות מערכות הציע, לשם ייעול, להוריד את הסנכרון של המתודה, ותחת זאת לסנכרן רק את הבלוק בחלק השני, כמתואר בקוד שלפניכם (השינויים שביצע הסטודנט מודגשים): class ProtocolTask implements Runnable { private final ServerProtocol l _protocol; private final StringMessageTokenizer _tokenizer; private final ConnectionHandler _handler; /* The fifo queue, which holds data coming from the socket. Access to the queue is serialized, to ensure correct *processing order - even if i f more data is received by the reactor while previous data is still being processed.*/ private final Vector<ByteBuffer> _buffers = new Vector<ByteBuffer>(); 6

7 7 public synchronized void run() { // first, add all the bytes we have to the tokenizer synchronized (_buffers) { while(_buffers.size() > 0) { ByteBuffer buf = _buffers.remove(0); this._tokenizer.addbytes(buf); // now, go over all complete messages and process them. synchronized (this) { while (_tokenizer.hasmessage()) { String msg = _tokenizer.nextmessage(); String response = this._protocol.processmessage(msg); if (response!= null) { try { ByteBuffer bytes = _tokenizer.getbytesformessage(response); this._handler.addoutdata(bytes); catch (CharacterCodingException e) { e.printstacktrace(); // This is invoked by the ConnectionHandler which runs in the reactor main thread. public void addbytes(bytebuffer b) { synchronized (_buffers) { _buffers.add(b); האם השינוי שהציע הסטודנט עשוי לפגום בפעילותן התקינה של המדרגות הנעות, בסימולציה הנתונה? נמקו תשובתכם. [10 נקודות] הנחיה: הבהירו לעצמכם אלו ת'רדים בשרת עובדים במקביל על חלקים שונים של המצב הפנימי ב,ProtocolTask ומתי זה קורה.,this איזה עיקרון בפרוטוקול זה בא להבטיח? על run() עימדו על הסיבה לסינכרון כל המתודה למעוניינים (זה לא בהכרח נדרש), ניתן למצוא בנספח (בסוף המבחן) את החלקים הרלבנטיים של ConnectionHandler המחלקה 7

8 8 10) שאלה 4 נקודות) לשם מעקב ובקרה אחר יעילות ההפעלה של המדרגות הנעות באתרים השונים, החליט זכיין הפעלה לשמור בבסיס נתונים, מידע סטטיסטי על המשתמשים במדרגות. עבור כל גרם מדרגות: מיקום גרם המדרגות (שם הארץ, שם העיר, שם המתחם) - אוריינטציה (עולה או יורד) - רשימה של הימים בהם הוא הופעל - תאריך o מספר עוברים ביום זה o זמן ממוצע למעבר ממפלס למפלס o א. ב. הגדירו מודל נתונים (טבלאות ומפתחות) עבור המערכת שתוארה לעיל. [5 נקודות] הגדירו שאילתת SQL המחזירה את כמות האנשים שעברה בכל אחד מגרמי המדרגות (שם המתחם ומספר העוברים) הממוקמים בב"ש, בתאריך 2/1/11, ממוין ע"פ מספר האנשים בסדר עולה. [5 נקודות] 8

9 9 ConnectionHandler נספח: המחלקה public class ConnectionHandler { protected final SocketChannel _schannel; protected final ReactorData _data; protected final AsyncServerProtocol _protocol; protected final StringMessageTokenizer _tokenizer; protected Vector<ByteBuffer> _outdata; protected final SelectionKey _skey; private ProtocolTask _task; // Post data in the pending data queue, so that the connectionhandler will send it through the socket. // switchtoreadwritemode() subscribes scribes this handler key to the OP_WRITE event // This event will immediately fire because the output buffer of the channel is empty. // It will keep firing as long as the output buffer is not filled. // When we are done sending pending data, we will unsubscribe from OP_WRITE. public synchronized void addoutdata(bytebuffer buf) { _outdata.add(buf); switchtoreadwritemode(); // Reads incoming data from the client:. Reads some bytes from the SocketChannel // Create a protocoltask, to process this data, possibly generating an answer. // Inserts the Task to the ThreadPool public void read() { // Do not read if protocol has terminated. Only write of pending data is // allowed when the protocol asked to close the connection. if (_protocol.shouldclose()) return; SocketAddress address = _schannel.socket().getremotesocketaddress(); logger.info("reading from " + address); ByteBuffer buf = ByteBuffer.allocate(BUFFER_SIZE); int numbytesread = 0; try { numbytesread = _schannel.read(buf); catch (IOException e) { numbytesread = -1; if (numbytesread == -1) { // Is the channel closed? // No more bytes can be read from the channel logger.info("client on " + address + " has disconnected"); closeconnection(); // tell the protocol that the connection terminated. _protocol.connectionterminated(); 9

10 10 return; // Add the buffer to the protocol task buf.flip(); _task.addbytes(buf); // Add the protocol task to the reactor which will parse and process the data // when a thread becomes available for it. _data.getexecutor().execute(_task); // Attempts to send data to the client. if all the data has been succesfully sent, the ConnectionHandler will // automatically switch to read only mode, otherwise it will stay in its current mode (which is read / write). public synchronized void write() { if (_outdata.size() == 0) { // if nothing left in the output string, go back to read mode switchtoreadonlymode(); return; // If there is something to send - send the first byte buffer // We will return to this write() operation very soon because the selector will keep firing the OP_WRITE event // after we are done writing this buffer and check if there are more buffers to be sent. ByteBuffer buf = _outdata.remove(0); if f (buf.remaining()!= 0) { _schannel.write(buf); // Check if the buffer contains more data: we could not send all of the buffer in one write // (the output buffer of the socket got full). So we remember that there is more data to be sent. // We will receive a new OP_WRITE event when the output buffer of the socket // is not full anymore and complete the write operation then. if (buf.remaining()!= 0) _outdata.add(0, buf); // Check if the protocol l asked us to close this connection. // If it did, we remain open as long as there are pending data to be sent. // As soon as all the data has been sent, we can close the connection. if (_protocol.shouldclose()) { switchtowriteonlymode(); if (buf.remaining() == 0) { logger.info("disconnecting client on " + _schannel.socket().getremotesocketaddress()); ); closeconnection(); 10

11 11 גיליון תשובות מספר נבחן: 30) שאלה 1 נקודות) סעיף א (10 0<=size()<=capacity()=to()-from()+1 מסונכרנת, והתוכנה הנשמרת לעייל תמיד מתקיימת final המחלקה בטוחה כי הגישה לשדות שאינם,setPedestrian() אינה פוגמת באינווריאנטה, כי יזרק fromheight בבנאי, והאינדקס i ב ו toheight אי בדיקת ערכי,_pedestrians ובגישה אליו). (ביצירת המערך Exception V 0<=i,j<capacity() <capacity(), i!= אם כוללים באינווריאנטה את האילוץ, שהולך רגל אינו מופיע בשתי מדרגות בו זמנית ) j getpedestrian ( התכונה לא מתקיימת בהכרח בקוד הנתון. etpedestrian(i)!= getpedestrian etpedestrian(j) תנאי התחלה: 5 נקודות בטיחות: 5 נקודות (12 נקודות) public synchronized void advance(staircase staircase) throws InterruptedException { staircase!= null && (staircase staircase.get.getpedestrian Pedestrian(getHeight() - staircase.fromheight fromheight()) == this getheight() staircase.fromheight fromheight() getheight() staircase.to toheight Height()) && staircase.get.getpedestrian Pedestrian(getStrateg getstrategy().next( y().next(getheight()) - staircase. fromheight()) == null //@POST: getheight() == = getstrategy().next(@pre(getheight()) && staircase.get.getpedestrian Pedestrian(@pre(getHeight() - staircase.fromheight fromheight()) == null && staircase.getpedestrian(getheight() - staircase.fromheight fromheight() ()) ) == this סעיף ב synchronized(staircase) { while (!(staircase!= null && staircase.getpedestrian(_strategy.next(getheight()) - staircase. fromheight()) == null && (_height == staircase.fromheight() s _height == staircase.toheight() staircase.getpedestrian(_height - staircase. fromheight()) == this))) staircase.wait(); staircase.setpedestrian(null, _height - staircase.fromheight()); _height = _strategy.next(_height); staircase.setpedestrian(this, _height - staircase.fromheight()); staircase.notifyall(); staircase wait this הערה: בפיתרון זה קיימת סכנת חבק, בשל תפישת המנעול על אותו). עם היציאה ל על (המשחררת רק 1

12 12 מפתח ניקוד: תנאי התחלה: 3 נקודות תנאי סיום: 2 נקודות מימוש: 7 נקודות בבדיקת המימוש הושם דגש על הנקודות הבאות - מנגנון המתנה המבוסס על wait/notify - שימוש במוניטור מתאים (staircase) - רצף סנכרון בין בדיקת תנאי התחלה ועד ביצוע הפעולה - חישוב נכון של האינדקס בגרם המדרגות ביחס לגובה הולך הרגל - עדכון גובה הולך הרגל - עדכון המדרגות סעיף ג (8 נקודות) חבק של המתנה הדדית עשוי להתרחש, בין שני הולכי רגל האחד עולה והשני יורד, הנפגשים בשתי מדרגות סמוכות. חבק זה המכונה בשפה המקצועית חמור ג ר ם משתחרר בנוכחות הת'רד המבצע את המשימה,StairCaseMovementTask המביאה את הולכי הרגל החבוקים למפלס פתוח. 30) שאלה 2 נקודות) class StairCase { public: virtual ~StairCase(); ~ virtual int fromheight() const = 0; virtual int toheight() const = 0; virtual Pedestrian *getpedestrian(int i) const = 0; virtual void setpedestrian(pedestrian *pedestrian,int i) = 0; virtual int size() const = 0; virtual int capacity() const = 0; סעיף א (18 נקודות) class StairCaseImpl : public StairCase { private: const Pedestrian **_pedestrians; const int _fromheight; const int _toheight; public: StairCaseImpl(int fromheight, int toheight) { 2

13 13 _fromheight = fromheight; _toheight = toheight; _size=0; _pedestrians = new Pedestrian*[_toHeight - _fromheight + 1] ; virtual ~StairCaseImpl(){ delete[] _pedestrians; StairCaseImpl(const StairCase& other){ _fromheight = other.fromheight fromheight() (); _toheight = other. toheight(); _pedestrians = new Pedestrian*[other.capacity()] ; for(int i=0; i other.capacity(); i++){ _pedestrians[i] = other. getpedestrian(i); StairCaseImpl & operator=(const StairCase& other) { _fromheight = other. fromheight(); _toheight = other. toheight(); Delete elete[] pedestrians _pedestrians; _pedestrians = new Pedestrian*[other.capacity()] ; for(int i=0; i other.capacity(); i++){ _pedestrians[i] = other. getpedestrian(i); int fromheight () const { return _fromheight; int toheight () ( const { return _toheight; int capacity() const { return _toheight - _fromheight + 1; int size() const { int size=0; for(int i=0; i<_toheight - _fromheight + 1; i++){ if (_pedestrians[i]!=null) size++; return size; Pedestrian* getpedestrian(int i) const { return _pedestrians[i]; void setpedestrian(pedestrian *p, int i) { 3

14 14 _pedestrians[i] = p; ; סעיף ב (12 נקודות) Stack address value meaning pointer to upstaircase return address from Q _toheight _fromheight pointer to _pedestrians in heap 1020 *vtable pointer to downstaircase in heap _toheight _fromheight pointer to _pedestrians in heap 1000 *vtable Heap address value meaning 7000 _pedestrians[39] _pedestrians array 6012 _pedestrians[39] _pedestrians array _toheight _fromheight 6000 *vtable 5000 _pedestrians[39] _pedestrians array 4

15 15 Grading Key 1. Missing inheritance, missing implementation of StairCase, StairCaseImpl, missing virtual methods C++ Syntax, Constructor (ctor), Destructor (dtor) [ ] 3. Definition, allocation and free of pedestrian array: Copy Constructor (copy ctor), Operator= Memory diagram a. each missing entry -3 b. missing vtable pointers -4 (no multiple deduction if missing inheritance above) c. functions, return address (r.a), parameters on stack -3, stack, heap confusions ) שאלה 3 נקודות) סעיף א (10 נקודות) What are the changes required to make StairCase are remote interface are the following (as documented in ): 1. On the StairCase interface: - Mark the interface remote by extending java.rmi.remote - Add java.rmi.remoteexception to all methods in the interface 2. On the StairCaseImpl implementation (the remote object): - Inherit from the java.rmi.server.unicastremoteobject - Add java.rmi.remoteexception to all methods of the class 3. In the process that publishes the remote object (the class Simulation), make the remote object available, by registering it in the rmiregistry: - Naming.rebind(" :4004/StairCase1", upstaircase); - In the specific case, it makes sense to add a method to the interface to indicate it is now under control of the remote controller that ensures the staircase movement but this was not expected as part of this answer. 4. Make sure all the parameters passed to and returned by remote methods are either: - Primitive types (int, char ) - Serializable types - Remote objects In our case, the parameters passed in the StairCase interface are: int and Pedestrian. So we had to make sure that class Pedestrian is Serializable. [Making this list was sufficient to get credit issue 4 was not taken into account in the grading, any missing indication of 1, 2 or 3 above caused a 3 point deduction] Most common errors: - Not listing the RemoteExceptions 5

16 16 - Marking that a class or an interface throws exception (I was shocked how many students wrote something that strange). A class does not throw an exception only methods do. - Confuse extends and implements (the remote interface extends java.rmi.remote, the remote object extends java.rmi.server.unicastremoteobject). - Forget about the Serializable condition on parameters (was not counted in the grading) In code: interface StairCase extends java.rmi.remote { int fromheight() throws java.rmi.remoteexception emoteexception; int toheight() throws java.rmi.remoteexception; Pedestrian getpedestrian edestrian(int i) throws java.rmi.remoteexception; void setpedestrian edestrian(p (Pedestrian pedestrian,int i) throws java.rmi.remoteexception; int size() throws java.rmi.remoteexception Exception; int capacity() throws java.rmi.remoteexception; class StairCaseImpl implements StairCase extends java.rmi.server.unicastremoteobject { private final Pedestrian P edestrian[] _pedestrian edestrians; s; private final int _fromheight; private final int _toheight; StairCaseImpl(int fromheight, int toheight) throws java.rmi.remoteexception { _fromheight = fromheight; _toheight = toheight; _pedestrian edestrians s = new PedestrianP edestrian[_toheight - _fromheight + 1] ; public int fromheight ()throws ( java.rmi.remoteexception { return _fromheight; public int toheight ()throws java.rmi.remoteexception { return _toheight; public int capacity()throws throws java.rmi.remoteexception { return _pedestrian edestrians.length; s.length; public synchronized int size() s throws java.rmi.remoteexception { int size=0; for (Pedestrian p : _pedestrian edestrians) s) if (p!=null) size++; return size; public synchronized Pedestrian P getpedestrian edestrian(int i) throws java.rmi.remoteexception { return _pedestrian edestrians[i]; s[i]; public synchronized void setpedestrian edestrian(p (Pedestrian p, int i) throws java.rmi.remoteexception { _pedestrian edestrians[i] s[i] = p; 6

17 17 class Simulation { public static void main(string[] args) { StairCase upstaircase = new StairCaseImpl(1, 39); Naming.rebind(" :4004/StairCase1", upstaircase); Pedestrian pedestrian edestrian1 = new Passenger(1,new HurryUp()); ); Pedestrian pedestrian edestrian2 = new Passenger(39,new HurryDown()); new Thread(new StairCaseMovementTask asemovementtask (upstaircase,1000)).start(); // Would make sense to wait until the remote staircase movement task is started not necessary new Thread(new Pedestrian edestrianmovementtask (pedestrian edestrian1,1000, 1000, upstaircase)).start(); new Thread(new Pedestrian destrianmovementtask (pedestrian edestrian2,1000, upstaircase)).start(); interface Pedestrian extends java.io.serializable { int getheight(); void setheight(int int height); Strategy getstrategy(); void advance(staircase staircase); סעיף ב (7 נקודות) How many communication operations are necessary to move up a staircase by 3 steps? We look at what the RMI client does: StairCase upstaircase=(staircase)naming.lookup(" :4004/staircase1 new Thread(new StairCaseMovementTask (upstaircase,1000)).start(); The Naming.lookup() call causes one round-trip communication with the rmiregistry server. The other part is of the process is that the remote object upstaircase is accessed through the run() method of StairCaseMovementTask. So we look at the code of run(): public void run() { while (true) { try { for (int i=_staircase.capacity. capacity() ()-1; ; i>0; i--i --) ) { _staircase.setpedestrian edestrian(_staircase. _staircase.getp getpedestrian edestrian(i (i-1),i); Pedestrian p = _staircase.getp getpedestrian edestrian(i) i); if (p!=null) p.setheight(p.getheight()+1); getheight()+1); 7

18 18 _staircase.setp setpedestrian edestrian(null,0); null,0); synchromized(_staircase staircase) ) { _staircase.notifyall(); Thread.sleep(_speed); catch (InterruptedException e) { In this code, _staircase is bound to a remote object (that is, it is a stub that sends remote calls to the remote object). This means each call on _staircase is a remote call and we want to call such remote calls each call is a round-trip communication operation. The calls are: For each iteration in the while(true) loop: In the for loop (capacity() times): getpedestrian() setpedestrian() setpedestrian(null) [We can either ignore the notifyall() call as indicated in the question or count it as a remote variant] Total: (capacity() * 2 + 1) calls per iteration. Each iteration moves the stair by 1 step up. We want to count 3 steps up: 3 * (capacity() * 2 + 1) + 1 (lookup) We know that capacity() is 39 in our case giving: 3 * (39 * 2 + 1) + 1 = 238 round trip operations. Possible variation: - Some students assumed that the Pedestrian interface is a remote interface instead of being a serializable interface. This is fine and in this case, p.setheight() and p.getheight() must be counted as 2 round-trip calls in the loop. Most common errors: - Not counting the operations at all (detail which operations are remote calls). - Giving a random number as an answer. - Not taking into account the loop over the capacity(). - Not taking into account the loop for 3 steps - Not counting the lookup() operation [Either loops omission was counted as 2 point deduction] סעיף ג (3 נקודות) Must the class StairCaseImpl.class be present in the file system side of the process running StairCaseControl? 8

19 19 No it does not since this is a remote object, which is accessed through the remote interface StairCase. When StairCaseControl executes: StairCase upstaircase=(staircase)naming.lookup(" :4004/staircase1 It gets in return an instance of the stub class (StairCaseStub.class) which implements the StairCase interface. It never accesses the staircaseimpl code, which is only operated on the side of the Simulation process. סעיף ד (10 נקודות) Assume the implementation of the skel uses the Reactor pattern. A student proposes to remove the synchronized directive on the run() method of ProtocolTask, and instead to limit it half of the method (dealing with the tokenizer and protocol and not with the part dealing with the buffers and tokenizer). - Does the change affect correctness? - What is the condition that the synchronized run() enforces? First why is run() synchronized? Notes from the reactor pattern: - A protocoltask instance is associated to a single connectionhandler. That means, a protocoltask will only operate on the same client connection. There is only one protocoltask per connectionhandler. - The protocoltask is submitted to the thread pool executor each time new data is read by the connectionhandler (in the read() method). When run() is synchronized, we know that the calls to run() from the executor will be serialized (executed sequentially one after the other) so that 2 threads from the thread pool cannot execute the same task simultaneously. If we remove the synchronized directive from run(), then there can be the following situation: - ConnectionHandler receives a read event from the reactor and posts its task to the thread pool for execution. - Thread T1 from the thread pool starts running the task. - Another read event arrives from the reactor to the ConnectionHandler and the same task is posted again to the thread pool for execution. - Thread T2 from the thread pool starts running the same task while T1 is still working on the same task. Can this fact cause correctness problems? - If the 2 read events come from 2 separate messages m1 and m2 sent from the same client, then this could potentially lead to a situation where the server processes m2 before m1 and it does not respect the order of messages sent by the client. - If the 2 read events come from 2 fragments of the same message m1, or from fragments that overlap 2 distinct messages m1 and m2, then potentially, this situation could lead to a situation where the bytes are added to the tokenizer in the wrong order. 9

20 20 Note that the other way to access the protocol task is through the method addbytes() which is invoked by the ConnectionHandler (in the reactor thread), when it receives data in the read() event. But note that addbytes() is NOT synchronized and this is on purpose. The buffers queue serves as a buffer between the reactor thread (producer) and the thread running the protocoltask (consumer). Between these 2 active objects, only the buffers object needs to be synchronized, and it is properly synchronized in all places where buffers is accessed. Now we need to look at the details because the proposed code does not completely remove the synchronization it moves it from one place to another (smaller scope). So can we really get the risks highlighted above? With the synchronization proposed by the student, we have 2 sections the sync(buffers) part, and the sync(this) part. So we can now get the situation with 2 threads active on the same ProtocolTask instance: - T1 is inside part1 (moves buffers from buffers to tokenizer) - T2 is inside part2 (moves messages from tokenizer to protocol, execute protocol and pass return data to connectionhandler). But we cannot have a situation where T1 and T2 are together in part1 or together in part2. Risk 1: (protocol processes m2 before m1) cannot happen because the messages are inserted in order from buffers to tokenizer: only the reactor thread adds to buffers so buffers is always ordered, and whether T1 or T2 read from buffers, they always push to the same tokenizer so tokenizer gets data in the proper order. Since only one thread can read complete messages from tokenizer at a time, and the sequence read message / execute message is synchronized, there is no risk of message order inversion. Risk 2: (buffers with partial messages are pushed into tokenizer in the wrong order) cannot happen because buffers are pushed into tokenizer by one thread at a time and the sequence buffers.remove() / tokenizer.add() is synchronized. Note that the only element that is shared between part1 and part2 is the tokenizer and we must make sure that tokenizer is properly fully synchronized. In the reactor code, this is indeed the case. All in all the changes proposed by the student are safe. Note: we do not discuss here whether the changes are beneficial or not to the reactor. They could increase parallelism but they could also reduce scalability it depends on the pattern of communication between clients and server (many fragmented messages, several messages sent in sequence by the client without getting a response from the server). This is out of the scope of the question. Grading considered: - Any mention of message ordering got a credit of 5 points or more. - Any mention of partial messages ordering got a credit of 3 points or more. - Any mention that tokenizer must be fully synchronized got a credit of 5 points or more. - Explanation that lack of synchronization brings risk is not sufficient we expected specific explanation of the risks. 10

21 21 - Explanation that there is only one client for this server were wrong. The risks exist even with a single client. 30) שאלה 4 נקודות) סעיף א (5 נקודות) Data Model: create table Location ( LocationId int primary key, LocationName varchar(200), City varchar(200), Country varchar(100)) create table Staircase ( StaircaseId int Primary Key, LocationId int Foreign Key references Location, Orientation int // 1 = ascending, 2 = descending ) create table StaircaseOperation ( StaircaseId int Foreign Key references Staircase, OperationDay datetime, PassengersNumber int, AverageTripDuration int, // average duration in milliseconds Primary Key (StaircaseId, OperationDay) ) Common Errors: - Types of fields must be specified (int, varchar, date, Boolean) [1 point] - Primary Keys must be specified for each table [2 to 3 points] - Primary Keys must be unique for each table [OperationDay alone in StaircaseOperation is not unique, it cannot be PK] - Foreign Keys must be specified [2 to 3 points] - When there is a relation 1-n from T1 to T2, then the foreign key is in table T2. In our example, the relation Staircase to StaircaseOperations is 1-n (there is one row of Operations for each date for each staircase). Therefore, the foreign key (StaircaseId) is in the table StaircaseOperations (and not the opposite a date field in the Staircase table). - Tables must be normalized [Was not penalized] - If there is a group of fields that are repeated in many rows, normalization consists of replacing these fields with a foreign key to a table where the group of fields are stored. For example, since LocationName, City and Country could possibly be repeated many times for each staircase in each location in the same city, we defined the table Location to normalize the schema. 11

22 22 סעיף ב (5 נקודות) Select Staircase.StaircaseId, Location.LocationName, StaircaseOperation.PassengersNumber From ((Staircase inner join Location on Staircase.locationId = Location.LocationId) inner join staircaseoperation on staircase.staircaseid = staircaseoperation.staircaseid) Where Location.city = 'Beer Sheva' and StaircaseOperation.OperationDay = ' ' Order by StaircaseOperation.PassengersNumber asc 12